home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_100 / 111_01 / se.c < prev    next >
Encoding:
C/C++ Source or Header  |  1985-08-19  |  12.1 KB  |  600 lines
  1. /*
  2. HEADER:        ;
  3. TITLE:        Diskette sector editor;
  4. VERSION:    1.4;
  5.  
  6. DESCRIPTION:    "Lets you view, edit and write back a diskette sector.
  7.  
  8.         It needs a 24*80 cursor-addressable terminal, and requires
  9.         your custom CLRSCREEN() and GOTOXY() functions.  The
  10.         definitions of these functions appear early in SE.C.
  11.  
  12.         Compiling requires SENTER.C, included on the diskette.
  13.         Also included are SE.DOC and SE.SUB.";
  14.  
  15. KEYWORDS:    Disk, utility, editor, sector;
  16. SYSTEM:        CP/M-80, V2.2;
  17. FILENAME:    SE.C;
  18. WARNINGS:    "Requires Version 2.x of CP/M.
  19.         SE is not designed to work with systems using the DEBLOCK
  20.         routine in the BIOS to handle physical sectors larger than
  21.         128 bytes, so if you have such a system, and want to use SE,
  22.         you must modify the routines in SE which write back the edited
  23.         sector.  The BitMap command is not implemented.";
  24.  
  25. SEE-ALSO:    SE.DOC, SENTER.C;
  26. AUTHORS:    Jan Larsson;
  27. COMPILERS:    BDS C, v1.43 and 1.5a;
  28. */
  29. /************************************************************************
  30.  
  31. Version 1.0:
  32.     SE uses 2.x functions which are not available on CP/M 1.x,
  33.     so it will need patching for running under 1.x.  Functions
  34.     for handling XY and CLEAR screen are at the beginning of SE.C.
  35.     Jan Larsson, Kosterv. 12, S-181 35  Lidingo, SWEDEN
  36.  
  37. ************************************************************************/
  38.  
  39. #include <bdscio.h>
  40.  
  41. #define YOFF 6
  42. #define XOFF 7
  43. #define AYOFF 6
  44. #define AXOFF 60
  45. #define LEFT 0x13
  46. #define RIGHT 0x04
  47. #define UP 0x05
  48. #define DOWN 0x18
  49. #define ESC 0x1B
  50.  
  51.  
  52. struct dp {
  53.     unsigned spt ;
  54.     char blocks ;
  55.     char blockm ;
  56.     char nullm ;
  57.     unsigned dsiz ;
  58.     unsigned dirsiz ;
  59.     char all0 ;
  60.     char all1 ;
  61.     unsigned checksiz ;
  62.     unsigned tracko ;
  63.     };
  64.  
  65. struct dp *pdp ;
  66.  
  67. unsigned maxtrack, maxsec, spb, ctrack, csec, cblock, trans, *ptrans ;
  68. char cbuf[128], line[128], tbuf[80] ;
  69. char a,b,c ;
  70. unsigned x,y,z ;
  71.  
  72.     
  73.  
  74. /*
  75. **  Send a character to the video terminal
  76. */
  77.  
  78. pchar( c )
  79. char c ;
  80. {
  81.     bios( 4, c );
  82. }
  83.  
  84.  
  85. /*
  86. **  Get a char from keyboard
  87. */
  88.  
  89. gchar()
  90. {
  91.     return( toupper( bios(3) ) );
  92. }
  93.  
  94.  
  95. /*
  96. **  Clear the screen
  97. */
  98.  
  99. clrscreen()
  100. {
  101.     pchar( 26 );
  102. }
  103.  
  104.  
  105. /*
  106. **  Cursor adressing routine, y = vertical 0...n, x = horizontal 0...n
  107. */
  108.  
  109. gotoxy( x, y )
  110. char x, y ;
  111. {
  112.     pchar( ESC );
  113.     pchar( '=' );
  114.     pchar( y + 32 );
  115.     pchar( x + 32 );
  116. }
  117.  
  118.  
  119. /*
  120. **  Handle cursor positioning on a HEX map of memory
  121. **  on the screen, 128 bytes as 8 rows of 16 bytes.
  122. **  One space between bytes on screen
  123. */
  124.  
  125. hxy( pos )
  126. unsigned pos;
  127. {
  128.     char x, y ;
  129.  
  130.     y = pos / 32 + YOFF ;
  131.     x = pos % 32 ;
  132.     x += x/2 + XOFF ;
  133.     gotoxy( x, y );
  134. }
  135.               
  136.  
  137. /*
  138. **  Cursor positioning on the ASCII display, 8 rows of 16 chars
  139. */
  140.  
  141. axy( pos )
  142. unsigned pos ;
  143. {
  144.     char x, y ;
  145.  
  146.     pos /= 2 ;
  147.     y = pos / 16 + AYOFF ;
  148.     x = pos % 16 + AXOFF ;
  149.     gotoxy( x, y );
  150. }
  151.  
  152.  
  153. /*
  154. **  The real workhorse editing routine, handles (almost) everything.
  155. */
  156.  
  157. unsigned hget( pos, buf )
  158. unsigned pos ;       
  159. char *buf ;
  160. {            
  161.     char c, d ;
  162.  
  163.     d = c = gchar();
  164.     if(c == 3)stop();
  165.     if(c >= '0' && c <= '9')c -= '0' ;
  166.     else if(c >= 'A' && c <= 'F')c = (c - 'A') + 10 ;
  167.     else {
  168.         switch( c ) {
  169.             case RIGHT  : if(pos < 255)pos++ ; hxy( pos ); return( pos );
  170.             case LEFT   : if(pos >   0)pos-- ; hxy( pos ); return( pos );
  171.             case UP     : if(pos >  31)pos -= 32 ; hxy( pos ); return( pos );
  172.             case DOWN   : if(pos < 224)pos += 32 ; hxy( pos ); return( pos );
  173.             case ESC    : hxy( pos ); return( ERROR );
  174.             case 0x01   : pos -= (pos % 32) ; hxy( pos ); return( pos );
  175.             case 0x06   : pos += (32 - (pos % 32)) - 1 ; hxy( pos ); return( pos );
  176.             case 0x1a   : pos = 0 ; hxy( pos ); return( pos );
  177.             default     : ermsg("Illegal HEX digit.");
  178.                           enter( 0, 18, " Command: ", 48, line, 0x62 );
  179.                            hxy( pos ); return( pos );
  180.             }
  181.         }
  182.     if(pos % 2 == 0)buf[ pos/2 ] = (buf[ pos/2 ] & 0x0f) | (c << 4) ;
  183.     else buf[ pos/2 ] = (buf[ pos/2 ] & 0xf0) | c ;
  184.     hxy( pos ); pchar( d );
  185.     axy( pos );
  186.     if(buf[ pos/2 ] >= ' ' && buf[ pos/2 ] <= 0x7e)pchar( buf[ pos/2 ] ) ;
  187.     else pchar('.');
  188.     if(pos < 255)pos++ ;
  189.     hxy( pos );        
  190.     return( pos );
  191. }    
  192.  
  193.  
  194. /*
  195. **  Display a 128 byte buffer on screen
  196. */
  197.  
  198. display( buf )
  199. char *buf ;
  200. {
  201.     unsigned ppos ;
  202.     char c, i ;
  203.  
  204.     gotoxy( 0, YOFF );
  205.     ppos = 0 ;
  206.     while(ppos < 255){
  207.         printf("%04x:  ", ppos/2 );
  208.         hxy( ppos );
  209.         for(i = 0 ; i < 16 ; i++ )printf("%02x ", buf[ ppos/2 + i ] );
  210.         axy( ppos );
  211.         for(i = 0 ; i < 16 ; i++ ){
  212.             c = buf[ ppos/2 + i ] ;
  213.             if(c >= ' ' && c <= 0x7e)pchar( c );
  214.             else pchar('.');
  215.             }
  216.         ppos += 32 ;
  217.         printf("\n");
  218.         }
  219.     ppos = 0 ;
  220.     hxy( ppos );
  221. }
  222.  
  223.  
  224. /*
  225. **  Stop immediately, and return to DOS
  226. */
  227.  
  228. stop()
  229. {
  230.     gotoxy(0,22);
  231.     exit();
  232. }
  233.  
  234.  
  235. /*
  236. **  Display ERROR message on screen
  237. */
  238.  
  239. ermsg( s )
  240. char *s ;
  241. {
  242.     gotoxy( 10, 18 );
  243.     printf("ERR: %s ", s );
  244.     gchar();
  245. }
  246.                          
  247.  
  248.  
  249. /*
  250. **  CHECKPAR checks the track sector parameters
  251. */
  252.  
  253. checkpar( track, sector )
  254. unsigned track, sector ;
  255. {
  256.     if(track > maxtrack){ ermsg("Too large track number.");
  257.                           return( FALSE );
  258.                         }
  259.     if(sector > maxsec){ ermsg("Too large sector number");
  260.                           return( FALSE );
  261.                         }
  262.     if(sector == 0){ ermsg("Sector number cant be 0");
  263.                      return( FALSE );
  264.                     }
  265.     return(TRUE);
  266. }
  267.  
  268.  
  269.  
  270. /*
  271. **  PSEC stores a sector, using actual skewing factor
  272. */
  273.  
  274. psec( track, sector, buffer )
  275. unsigned track, sector ;
  276. char *buffer ;
  277. {
  278.     if(track >= pdp -> tracko)sector = sectran( (sector - 1) );
  279.     bios( 10, track );
  280.     bios( 11, sector );
  281.     bios( 12, buffer );
  282.     bios( 14 );
  283. }
  284.  
  285.  
  286.  
  287.  
  288. /*
  289. **  GSEC fetches a sector, using actual skewing factor
  290. */
  291.  
  292. gsec( track, sector, buffer )
  293. unsigned track, sector ;
  294. char *buffer ;
  295. {
  296.     if(track >= pdp -> tracko)sector = sectran( (sector - 1) );
  297.     bios( 10, track );
  298.     bios( 11, sector );
  299.     bios( 12, buffer );
  300.     bios( 13 );
  301. }
  302.  
  303.  
  304.  
  305.  
  306. /*
  307. **  Header displays the header at the top of the page
  308. */
  309.  
  310. header()
  311. {
  312.     printf("Ayatollans Mjukisar");
  313.         gotoxy( 26,0 );
  314.         printf("S E C T O R  E D I T O R");
  315.     gotoxy( 68, 0 );
  316.     printf("Version 1.4");          
  317.         gotoxy( 0, 1 );
  318.         printf("----------------------------------------");
  319.         printf("----------------------------------------");
  320. }
  321.  
  322.  
  323.  
  324. /*
  325. **  Display the commands at the lowest line of the
  326. **  the screen.
  327. */
  328.  
  329. docs()
  330. {
  331.     gotoxy( 0, 21 );
  332.     printf(" NewDisk/Look/Edit/Write/Bye/BitMap/Drive");
  333. }
  334.  
  335.  
  336. /*
  337. **  copy the n-th item of command line into spec mini-buf
  338. */
  339.  
  340. ctok( buf, line, n )
  341. char *buf, *line ;
  342. char n ;
  343. {
  344.     char *p1, *p2, i, ccc, bool ;
  345.  
  346.     bool = FALSE ;
  347.     *buf = NULL ;
  348.     p1 = line ;
  349.     while(*p1 == ' ' && *p1 != NULL)p1++ ;
  350.     i = 1 ;
  351.     while(i < n && *p1 != NULL){
  352.         while(*p1 != ' ' && *p1 != NULL)p1++ ;
  353.         while(*p1 == ' ' && *p1 != NULL)p1++ ;
  354.         i++ ;
  355.         }
  356.     if(*p1 != NULL){
  357.         p2 = p1 ;
  358.         while(*p2 != ' ' && *p2 != NULL)p2++ ;
  359.         ccc = *p2 ;
  360.         *p2 = NULL ;
  361.         strcpy( buf, p1 );
  362.         *p2 = ccc ;
  363.         }
  364. }
  365.  
  366.     
  367.  
  368. /*
  369. **  Display the maximum numbers
  370. */
  371.  
  372. dispmax()
  373. {
  374.     gotoxy( 0, 3 );
  375.     printf("CP/M Max block:%4d   Disk Size:%5d kbyte", 
  376.                 pdp -> dsiz,
  377.                 (pdp -> dsiz + 1) * (spb / 8) );
  378.     printf("   Max Track:%3d    Max Sector:%3d", maxtrack, maxsec );                                                    
  379. }
  380.  
  381.  
  382.  
  383. /*
  384. ** After getting new track/sector adresses, calc and display new
  385. ** block numbers etc.
  386. */
  387.  
  388.  
  389. calc()
  390. {    
  391.     gotoxy( 0, 16 );
  392.     cblock = ((ctrack - pdp -> tracko) * maxsec + csec) / spb ;
  393.     printf("CP/M Block number: %4d/%x     ", cblock, cblock );
  394.     printf("Track number: %3d      ", ctrack );
  395.     printf("Sector number: %3d    ", csec );
  396. }
  397.  
  398.  
  399. /*
  400. **  SELDSK call bios routine for seldsk, return whatever
  401. **  BIOS returns in HL
  402. */
  403.  
  404. seldsk( drive )
  405. char drive ;
  406. {
  407.     unsigned *p, d ;
  408.  
  409.     p = 1 ;
  410.     d = *p ;
  411.     d = d + 24 ;
  412.     return( call( d, 0, 0, drive, 0 ) );
  413. }
  414.  
  415.  
  416.  
  417. /*
  418. **  SECTRAN calls the sectran routine in users BIOS
  419. */
  420.  
  421. sectran( secno )
  422. char secno ;
  423. {
  424.     unsigned p ;
  425.  
  426.     ptrans = 1 ;
  427.     p = *ptrans ;
  428.     p += 0x2d ;            
  429.     return( call( p, 0, 0, secno, trans ) );
  430. }
  431.  
  432.  
  433. bitmap(){;;}
  434.  
  435.  
  436. /*
  437. **  Initialize all those disk parameters
  438. */
  439.  
  440. idisk()
  441. {
  442.     trans = bdos( 25 );
  443.     ptrans = seldsk( trans );
  444.     trans = *ptrans ;
  445.     pdp = bdos( 31 );
  446.     spb = 1 << pdp -> blocks ;
  447.     maxsec = pdp -> spt ;
  448.     maxtrack = pdp -> tracko + ((pdp -> dsiz * spb) / maxsec) ;
  449.     ctrack = 0 ;
  450.     csec = 1 ;
  451.     cblock = ((ctrack - pdp -> tracko) * maxsec + csec) / spb ;
  452.     gsec( ctrack, csec, cbuf );
  453. }
  454.  
  455.  
  456. main()
  457. {
  458.     char *p ;
  459.     unsigned g ;
  460.  
  461.  
  462.     clrscreen();
  463.     header();
  464.     docs();
  465.     idisk();
  466.     calc();
  467.     dispmax();
  468.     gsec( ctrack, csec, cbuf );
  469.     display( cbuf );
  470.     for(;;){
  471.         enter( 0, 18, " Command: ", 48, line, 0x76 );
  472.         ctok( tbuf, line, 1 );
  473.         a = tbuf[0] ;
  474.         ctok( tbuf, line, 2 );
  475.         b = tbuf[0] ;
  476.         ctok( tbuf, line, 3 );
  477.         x = atoi( tbuf );
  478.         ctok( tbuf, line, 4 );
  479.         c = tbuf[0] ;
  480.         ctok( tbuf, line, 5 );
  481.         y = atoi( tbuf );
  482.         ctok( tbuf, line, 1 );
  483.         switch (a) {
  484.             case 'N' : idisk(); calc(); dispmax(); break ;
  485.             case 'B' : if(tbuf[1] == 'Y')stop();
  486.                        else bitmap();
  487.                        break ;
  488.             case 'D' : if(seldsk( b - 'A' ) == 0)ermsg("NO such drive known to me");
  489.                        else { bdos( 14, b - 'A' ); idisk(); calc(); dispmax();};
  490.                        break ;
  491.             case 'L' : if(b == 'T'){ ctrack = x ;
  492.                                      if(c == 'S')csec = y ;
  493.                                      else { ermsg("Illegal second parameter");
  494.                                             break;
  495.                                           }
  496.                                    }
  497.                        else if(b == 'S'){ csec = x ;
  498.                                      if(c == 'T')ctrack = y ;
  499.                                      else { ermsg("Illegal second parameter");
  500.                                             break ;
  501.                                           }
  502.                                      }
  503.                        else if(b == '+'){
  504.                                     csec++ ;
  505.                                     if(csec > maxsec){csec = 1 ; ctrack++ ; }
  506.                                     }
  507.                         else if(b == '-'){
  508.                                     csec-- ;
  509.                                     if(csec < 1){csec = maxsec ; ctrack-- ; }
  510.                                     }
  511.                        else { ermsg("Illegal first parameter");
  512.                               break ;
  513.                             }
  514.                        if(!checkpar( ctrack, csec ))break;
  515.                        calc();
  516.                        gsec( ctrack, csec, cbuf );
  517.                        display( cbuf );
  518.                        break ;
  519.             case 'E' : if(b == 'T'){ ctrack = x ;
  520.                                      if(c == 'S')csec = y ;
  521.                                      else { ermsg("Illegal second parameter");
  522.                                             break;
  523.                                           }
  524.                                    }
  525.                        else if(b == 'S'){ csec = x ;
  526.                                      if(c == 'T')ctrack = y ;
  527.                                      else { ermsg("Illegal second parameter");
  528.                                             break ;
  529.                                           }
  530.                                      }
  531.                        else if(b == '+'){
  532.                                     csec++ ;
  533.                                     if(csec > maxsec){csec = 1 ; ctrack++ ; }
  534.                                     }
  535.                         else if(b == '-'){
  536.                                     csec-- ;
  537.                                     if(csec < 1){csec = maxsec ; ctrack-- ; }
  538.                                     }
  539.                        else { ermsg("Illegal first parameter");
  540.                               break ;
  541.                             }
  542.                        if(!checkpar( ctrack, csec ))break ;
  543.                        calc();    
  544.                        gsec( ctrack, csec, cbuf );
  545.                        display( cbuf );
  546.                        p = cbuf ;
  547.                        g = 0 ;
  548.                        while((g = hget( g, p )) != ERROR);    
  549.                        break ;
  550.             case 'W' :  if(b == 'T'){ ctrack = x ;
  551.                                      if(c == 'S')csec = y ;
  552.                                      else { ermsg("Illegal second parameter");
  553.                                             break;
  554.                                           }
  555.                                    }
  556.                        else if(b == 'S'){ csec = x ;
  557.                                      if(c == 'T')ctrack = y ;
  558.                                      else { ermsg("Illegal second parameter");
  559.                                             break ;
  560.                                           }
  561.                                      }
  562.                        else if(b == '+'){
  563.                                     csec++ ;
  564.                                     if(csec > maxsec){csec = 1 ; ctrack++ ; }
  565.                                     }
  566.                         else if(b == '-'){
  567.                                     csec-- ;
  568.                                     if(csec < 1){csec = maxsec ; ctrack-- ; }
  569.                                     }
  570.                        else { ermsg("Illegal first parameter");
  571.                               break ;
  572.                             }
  573.                        if(!checkpar( ctrack, csec ))break ;
  574.                        calc();
  575.                        psec( ctrack, csec, cbuf );
  576.                        break ;        
  577.                 default : ermsg("Illegal command");
  578.                 }
  579.             }
  580.         p = cbuf ;
  581.         display( p );
  582.         g = 0 ;
  583.         while((g = hget( g, p )) != ERROR);
  584.     }
  585.     
  586.     
  587. /*
  588. **  A special version of putchar, uses direct BIOS calls
  589. */
  590.  
  591. putchar( c )
  592. char c ;
  593. {
  594.     if(c == '\n')bios( 4, 0x0d );
  595.     bios( 4, c );
  596.     if(bios(2))stop();
  597. }
  598.  
  599.  
  600.